/************************************************************************
 * <br>
 * <ul>
 * <li>版权所有：唐山弘川科技有限公司 2009－2020</li>
 * <li>创建日期：2009-8-10</li>
 * <li>初始作者：刘川</li>
 * </ul>
 * <ul>
 * <b>修订历史</b>
 * <li>1、</li>
 * </ul>
 ***********************************************************************/
/*package com.hy.enterprise.framework.persistence.domain ;

import java.util.Collection;
import java.util.Date;

import javax.persistence.Entity;

import net.sf.cglib.proxy.MethodInterceptor;

import com.hy.enterprise.framework.lang.proxy.CglibProxyFactory;
import com.hy.enterprise.framework.persistence.domain.query.ISubQuery;
import com.hy.enterprise.framework.persistence.domain.query.InCollection;
import com.hy.enterprise.framework.persistence.domain.query.SelectClause;
import com.hy.enterprise.framework.persistence.domain.query.SortDirection;
import com.hy.enterprise.framework.persistence.domain.query.conditions.AllOrAny;
import com.hy.enterprise.framework.persistence.domain.query.conditions.AllOrAnyOperator;
import com.hy.enterprise.framework.persistence.domain.query.conditions.BetweenOperator;
import com.hy.enterprise.framework.persistence.domain.query.conditions.BinaryExpression;
import com.hy.enterprise.framework.persistence.domain.query.conditions.ComparisonOperator;
import com.hy.enterprise.framework.persistence.domain.query.conditions.ConditionalExpression;
import com.hy.enterprise.framework.persistence.domain.query.conditions.EqualityOperator;
import com.hy.enterprise.framework.persistence.domain.query.conditions.LikeOperator;
import com.hy.enterprise.framework.persistence.domain.query.conditions.TernaryExpression;
import com.hy.enterprise.framework.persistence.domain.query.internal.AliasFactory;
import com.hy.enterprise.framework.persistence.domain.query.internal.LibraPersistentObjectFactory;
import com.hy.enterprise.framework.persistence.domain.query.internal.PropertyAccessRecordingInvocationHandler;
import com.hy.enterprise.framework.persistence.domain.query.internal.managedobjects.CollectionAssociationPath;
import com.hy.enterprise.framework.persistence.domain.query.internal.managedobjects.LibraManagedObject;
import com.hy.enterprise.framework.util.lang.ObjectUtil;

*//**
 * <ul>
 * <li>设计作者：刘川</li>
 * <li>设计日期：2009-8-10</li>
 * <li>设计时间：下午04:58:23</li>
 * <li>设计目的：</li>
 * </ul>
 * <ul>
 * <b>修订历史</b>
 * <li>1、</li>
 * </ul>
 *//*
public class DomainQuery
{
	private static MethodInterceptor	interceptor	=
	                                                  new PropertyAccessRecordingInvocationHandler ( ) ;

	public static final SortDirection	ASC	        =
	                                                  SortDirection.ASC ;

	public static final SortDirection	DESC	    =
	                                                  SortDirection.DESC ;

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:00:58</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param clazz
	 * @return
	 *//*
	private static String inferEntityName (
	                                        Class < ? > clazz )
	{
		Entity entityAnnotation =
		                          clazz
		                               .getAnnotation ( Entity.class ) ;
		if ( entityAnnotation == null )
		{
			throw new IllegalArgumentException (
			                                     "类型：["
			                                             + clazz
			                                             + "]并不是JPA持久化数据模型类" ) ;
		}
		return ""
		         .equals ( entityAnnotation
		                                   .name ( ) )
		                                              ? clazz
		                                                     .getSimpleName ( )
		                                              : entityAnnotation
		                                                                .name ( ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午04:59:16</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <T>
	 * @param clazz
	 * @param alias
	 * @return
	 *//*
	public static < T > T alias (
	                              Class < T > clazz ,
	                              String alias )
	{

		T abstractSchemaName =
		                       CglibProxyFactory.INSTANCE
		                                                 .createProxy (
		                                                                clazz
		                                                                     .getClassLoader ( ) ,
		                                                                DomainQuery.interceptor ,
		                                                                clazz ) ;
		String entityType =
		                    DomainQuery
		                                    .inferEntityName ( clazz ) ;
		AliasFactory
		            .rememberAsAbstractSchemaName (
		                                            abstractSchemaName ,
		                                            entityType ,
		                                            alias ) ;
		return abstractSchemaName ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:04:15</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <T>
	 * @param <U>
	 * @param collection
	 * @param alias
	 * @return
	 *//*
	@ SuppressWarnings ( "unchecked" )
	public static < T , U extends T > U alias (
	                                            Collection < T > collection ,
	                                            String alias )
	{
		CollectionAssociationPath < U > collectionAssociationPath =
		                                                            ( CollectionAssociationPath < U > ) AliasFactory
		                                                                                                            .about ( collection ) ;
		String path =
		              AliasFactory
		                          .about (
		                                   collection )
		                          .getTargetRepresentation ( ) ;

		U elementProxy =
		                 collectionAssociationPath
		                                          .getElementProxy ( ) ;
		AliasFactory
		            .rememberAsAliasedAssociationPath (
		                                                elementProxy ,
		                                                path ,
		                                                alias ) ;
		return elementProxy ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:03:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <T>
	 * @param <U>
	 * @param inCollection
	 * @param alias
	 * @return
	 *//*
	@ SuppressWarnings ( "unchecked" )
	public static < T , U extends T > U alias (
	                                            InCollection < T > inCollection ,
	                                            String alias )
	{
		CollectionAssociationPath < U > collectionAssociationPath =
		                                                            ( CollectionAssociationPath < U > ) AliasFactory
		                                                                                                            .about ( inCollection
		                                                                                                                                 .getCollection ( ) ) ;
		String path =
		              AliasFactory
		                          .about (
		                                   inCollection
		                                               .getCollection ( ) )
		                          .getTargetRepresentation ( ) ;

		U elementProxy =
		                 collectionAssociationPath
		                                          .getElementProxy ( ) ;
		AliasFactory
		            .rememberAsAliasedInCollection (
		                                             elementProxy ,
		                                             path ,
		                                             alias ) ;
		return elementProxy ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:03:07</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <T>
	 * @param property
	 * @param alias
	 * @return
	 *//*
	public static < T > T alias (
	                              T property ,
	                              String alias )
	{
		String path =
		              AliasFactory
		                          .about (
		                                   property )
		                          .getTargetRepresentation ( ) ;
		AliasFactory
		            .rememberAsAliasedAssociationPath (
		                                                property ,
		                                                path ,
		                                                alias ) ;
		return property ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:26</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param subquery
	 * @return
	 *//*
	public static < W > AllOrAny < W > all (
	                                         final ISubQuery < W > subquery )
	{
		return new AllOrAny < W > (
		                            AllOrAnyOperator.ALL ,
		                            subquery ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:20</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param subquery
	 * @return
	 *//*
	public static < W > AllOrAny < W > any (
	                                         final ISubQuery < W > subquery )
	{
		return new AllOrAny < W > (
		                            AllOrAnyOperator.ANY ,
		                            subquery ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:40:08</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Character lhs ,
	                                              Character rhs1 ,
	                                              Character rhs2 )
	{
		return new TernaryExpression < Character , Character , Character > (
		                                                                     lhs ,
		                                                                     BetweenOperator.BETWEEN ,
		                                                                     rhs1 ,
		                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:40:03</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Character lhs ,
	                                              Character rhs1 ,
	                                              ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < Character , Character , ISubQuery < Character >> (
		                                                                                  lhs ,
		                                                                                  BetweenOperator.BETWEEN ,
		                                                                                  rhs1 ,
		                                                                                  rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:39:48</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Character lhs ,
	                                              ISubQuery < Character > rhs1 ,
	                                              Character rhs2 )
	{
		return new TernaryExpression < Character , ISubQuery < Character > , Character > (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:39:55</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Character lhs ,
	                                              ISubQuery < Character > rhs1 ,
	                                              ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < Character , ISubQuery < Character > , ISubQuery < Character >> (
		                                                                                                lhs ,
		                                                                                                BetweenOperator.BETWEEN ,
		                                                                                                rhs1 ,
		                                                                                                rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:59</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Date lhs ,
	                                              Date rhs1 ,
	                                              Date rhs2 )
	{
		return new TernaryExpression < Date , Date , Date > (
		                                                      lhs ,
		                                                      BetweenOperator.BETWEEN ,
		                                                      rhs1 ,
		                                                      rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:53</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Date lhs ,
	                                              Date rhs1 ,
	                                              ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < Date , Date , ISubQuery < ? extends Date >> (
		                                                                             lhs ,
		                                                                             BetweenOperator.BETWEEN ,
		                                                                             rhs1 ,
		                                                                             rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:45</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Date lhs ,
	                                              ISubQuery < ? extends Date > rhs1 ,
	                                              Date rhs2 )
	{
		return new TernaryExpression < Date , ISubQuery < ? extends Date > , Date > (
		                                                                              lhs ,
		                                                                              BetweenOperator.BETWEEN ,
		                                                                              rhs1 ,
		                                                                              rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:37</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Date lhs ,
	                                              ISubQuery < ? extends Date > rhs1 ,
	                                              ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < Date , ISubQuery < ? extends Date > , ISubQuery < ? extends Date >> (
		                                                                                                     lhs ,
		                                                                                                     BetweenOperator.BETWEEN ,
		                                                                                                     rhs1 ,
		                                                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:14</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Date > lhs ,
	                                              Date rhs1 ,
	                                              Date rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , Date , Date > (
		                                                                              lhs ,
		                                                                              BetweenOperator.BETWEEN ,
		                                                                              rhs1 ,
		                                                                              rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:05</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Date > lhs ,
	                                              Date rhs1 ,
	                                              ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , Date , ISubQuery < ? extends Date >> (
		                                                                                                     lhs ,
		                                                                                                     BetweenOperator.BETWEEN ,
		                                                                                                     rhs1 ,
		                                                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:54</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Date > lhs ,
	                                              ISubQuery < ? extends Date > rhs1 ,
	                                              Date rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , ISubQuery < ? extends Date > , Date > (
		                                                                                                      lhs ,
		                                                                                                      BetweenOperator.BETWEEN ,
		                                                                                                      rhs1 ,
		                                                                                                      rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:27</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Number > lhs ,
	                                              ISubQuery < ? extends Number > rhs1 ,
	                                              Number rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , ISubQuery < ? extends Number > , Number > (
		                                                                                                            lhs ,
		                                                                                                            BetweenOperator.BETWEEN ,
		                                                                                                            rhs1 ,
		                                                                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Number > lhs ,
	                                              Number rhs1 ,
	                                              ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , Number , ISubQuery < ? extends Number >> (
		                                                                                                           lhs ,
		                                                                                                           BetweenOperator.BETWEEN ,
		                                                                                                           rhs1 ,
		                                                                                                           rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:45</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < ? extends Number > lhs ,
	                                              Number rhs1 ,
	                                              Number rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , Number , Number > (
		                                                                                    lhs ,
		                                                                                    BetweenOperator.BETWEEN ,
		                                                                                    rhs1 ,
		                                                                                    rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:16</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < Character > lhs ,
	                                              Character rhs1 ,
	                                              Character rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , Character , Character > (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:36:08</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < Character > lhs ,
	                                              Character rhs1 ,
	                                              ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , Character , ISubQuery < Character >> (
		                                                                                                lhs ,
		                                                                                                BetweenOperator.BETWEEN ,
		                                                                                                rhs1 ,
		                                                                                                rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:35:52</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < Character > lhs ,
	                                              ISubQuery < Character > rhs1 ,
	                                              Character rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , ISubQuery < Character > , Character > (
		                                                                                                 lhs ,
		                                                                                                 BetweenOperator.BETWEEN ,
		                                                                                                 rhs1 ,
		                                                                                                 rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:35:22</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < String > lhs ,
	                                              ISubQuery < String > rhs1 ,
	                                              String rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , ISubQuery < String > , String > (
		                                                                                        lhs ,
		                                                                                        BetweenOperator.BETWEEN ,
		                                                                                        rhs1 ,
		                                                                                        rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:35:33</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < String > lhs ,
	                                              String rhs1 ,
	                                              ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , String , ISubQuery < String >> (
		                                                                                       lhs ,
		                                                                                       BetweenOperator.BETWEEN ,
		                                                                                       rhs1 ,
		                                                                                       rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:35:41</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              ISubQuery < String > lhs ,
	                                              String rhs1 ,
	                                              String rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , String , String > (
		                                                                          lhs ,
		                                                                          BetweenOperator.BETWEEN ,
		                                                                          rhs1 ,
		                                                                          rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:59</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Number lhs ,
	                                              ISubQuery < ? extends Number > rhs1 ,
	                                              ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < Number , ISubQuery < ? extends Number > , ISubQuery < ? extends Number >> (
		                                                                                                           lhs ,
		                                                                                                           BetweenOperator.BETWEEN ,
		                                                                                                           rhs1 ,
		                                                                                                           rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:06</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Number lhs ,
	                                              ISubQuery < ? extends Number > rhs1 ,
	                                              Number rhs2 )
	{
		return new TernaryExpression < Number , ISubQuery < ? extends Number > , Number > (
		                                                                                    lhs ,
		                                                                                    BetweenOperator.BETWEEN ,
		                                                                                    rhs1 ,
		                                                                                    rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:15</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Number lhs ,
	                                              Number rhs1 ,
	                                              ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < Number , Number , ISubQuery < ? extends Number >> (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:38:23</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              Number lhs ,
	                                              Number rhs1 ,
	                                              Number rhs2 )
	{
		return new TernaryExpression < Number , Number , Number > (
		                                                            lhs ,
		                                                            BetweenOperator.BETWEEN ,
		                                                            rhs1 ,
		                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:23</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              String lhs ,
	                                              ISubQuery < String > rhs1 ,
	                                              ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < String , ISubQuery < String > , ISubQuery < String >> (
		                                                                                       lhs ,
		                                                                                       BetweenOperator.BETWEEN ,
		                                                                                       rhs1 ,
		                                                                                       rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:31</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              String lhs ,
	                                              ISubQuery < String > rhs1 ,
	                                              String rhs2 )
	{
		return new TernaryExpression < String , ISubQuery < String > , String > (
		                                                                          lhs ,
		                                                                          BetweenOperator.BETWEEN ,
		                                                                          rhs1 ,
		                                                                          rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              String lhs ,
	                                              String rhs1 ,
	                                              ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < String , String , ISubQuery < String >> (
		                                                                         lhs ,
		                                                                         BetweenOperator.BETWEEN ,
		                                                                         rhs1 ,
		                                                                         rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:37:45</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression between (
	                                              String lhs ,
	                                              String rhs1 ,
	                                              String rhs2 )
	{
		return new TernaryExpression < String , String , String > (
		                                                            lhs ,
		                                                            BetweenOperator.BETWEEN ,
		                                                            rhs1 ,
		                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:16</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Date lhs ,
	                                         AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    EqualityOperator.EQUALS ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:10:03</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Date lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              EqualityOperator.EQUALS ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:09:56</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Date lhs ,
	                                         ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     EqualityOperator.EQUALS ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:11:18</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         ISubQuery < ? extends Date > lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      EqualityOperator.EQUALS ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:08:54</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         ISubQuery < ? extends Number > lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          EqualityOperator.EQUALS ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:35:01</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression eq (
	                                                             ISubQuery < V > lhs ,
	                                                             AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  EqualityOperator.EQUALS ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:52</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression eq (
	                                                             ISubQuery < V > lhs ,
	                                                             ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   EqualityOperator.EQUALS ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:11:58</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Number lhs ,
	                                         AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        EqualityOperator.EQUALS ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:09:07</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Number lhs ,
	                                         ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         EqualityOperator.EQUALS ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:09:11</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression eq (
	                                         Number lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  EqualityOperator.EQUALS ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:07:35</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression eq (
	                                                             V lhs ,
	                                                             AllOrAny < W > rhs )
	{
		return new BinaryExpression < V , AllOrAny < W >> (
		                                                    lhs ,
		                                                    EqualityOperator.EQUALS ,
		                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:06:52</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression eq (
	                                                             V lhs ,
	                                                             W rhs )
	{
		return new BinaryExpression < V , W > (
		                                        lhs ,
		                                        EqualityOperator.EQUALS ,
		                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:46</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param subquery
	 * @return
	 *//*
	public static ConditionalExpression exists (
	                                             final ISubQuery < ? > subquery )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return "EXISTS ("
				       + subquery
				                 .toString ( )
				       + ")" ;
			}

		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:34</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Character lhs ,
	                                         AllOrAny < Character > rhs )
	{
		return new BinaryExpression < Character , AllOrAny < Character >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.GT ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:29</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Character lhs ,
	                                         Character rhs )
	{
		return new BinaryExpression < Character , Character > (
		                                                        lhs ,
		                                                        ComparisonOperator.GT ,
		                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:23</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Character lhs ,
	                                         ISubQuery < Character > rhs )
	{
		return new BinaryExpression < Character , ISubQuery < Character >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.GT ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:16</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Date lhs ,
	                                         AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.GT ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Date lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              ComparisonOperator.GT ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:11</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Date lhs ,
	                                         ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.GT ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:16</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         ISubQuery < ? extends Date > lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.GT ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:08</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         ISubQuery < ? extends Number > lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          ComparisonOperator.GT ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:00</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         ISubQuery < Character > lhs ,
	                                         Character rhs )
	{
		return new BinaryExpression < ISubQuery < Character > , Character > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.GT ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:52</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         ISubQuery < String > lhs ,
	                                         String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                ComparisonOperator.GT ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:18:01</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression gt (
	                                                             ISubQuery < V > lhs ,
	                                                             AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  ComparisonOperator.GT ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:31</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression gt (
	                                                             ISubQuery < V > lhs ,
	                                                             ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   ComparisonOperator.GT ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:04</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Number lhs ,
	                                         AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        ComparisonOperator.GT ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:56</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Number lhs ,
	                                         ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         ComparisonOperator.GT ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:34:00</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         Number lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  ComparisonOperator.GT ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:33</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         String lhs ,
	                                         AllOrAny < String > rhs )
	{
		return new BinaryExpression < String , AllOrAny < String >> (
		                                                              lhs ,
		                                                              ComparisonOperator.GT ,
		                                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:25</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         String lhs ,
	                                         ISubQuery < String > rhs )
	{
		return new BinaryExpression < String , ISubQuery < String >> (
		                                                               lhs ,
		                                                               ComparisonOperator.GT ,
		                                                               rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:33:30</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gt (
	                                         String lhs ,
	                                         String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  ComparisonOperator.GT ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:26</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Character lhs ,
	                                          AllOrAny < Character > rhs )
	{
		return new BinaryExpression < Character , AllOrAny < Character >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.GTE ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:22</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Character lhs ,
	                                          Character rhs )
	{
		return new BinaryExpression < Character , Character > (
		                                                        lhs ,
		                                                        ComparisonOperator.GTE ,
		                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:13</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Character lhs ,
	                                          ISubQuery < Character > rhs )
	{
		return new BinaryExpression < Character , ISubQuery < Character >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.GTE ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:09</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Date lhs ,
	                                          AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.GTE ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:45</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Date lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              ComparisonOperator.GTE ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:32:03</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Date lhs ,
	                                          ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.GTE ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:24</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          ISubQuery < ? extends Date > lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.GTE ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:17</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          ISubQuery < ? extends Number > lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          ComparisonOperator.GTE ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:10</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          ISubQuery < Character > lhs ,
	                                          Character rhs )
	{
		return new BinaryExpression < ISubQuery < Character > , Character > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.GTE ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:07</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          ISubQuery < String > lhs ,
	                                          String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                ComparisonOperator.GTE ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:17:55</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression gte (
	                                                              ISubQuery < V > lhs ,
	                                                              AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  ComparisonOperator.GTE ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:30:48</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression gte (
	                                                              ISubQuery < V > lhs ,
	                                                              ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   ComparisonOperator.GTE ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:56</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Number lhs ,
	                                          AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        ComparisonOperator.GTE ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Number lhs ,
	                                          ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         ComparisonOperator.GTE ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:53</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          Number lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  ComparisonOperator.GTE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:42</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          String lhs ,
	                                          AllOrAny < String > rhs )
	{
		return new BinaryExpression < String , AllOrAny < String >> (
		                                                              lhs ,
		                                                              ComparisonOperator.GTE ,
		                                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:32</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          String lhs ,
	                                          ISubQuery < String > rhs )
	{
		return new BinaryExpression < String , ISubQuery < String >> (
		                                                               lhs ,
		                                                               ComparisonOperator.GTE ,
		                                                               rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:31:37</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression gte (
	                                          String lhs ,
	                                          String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  ComparisonOperator.GTE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:04:29</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <T>
	 * @param collection
	 * @return
	 *//*
	public static < T > InCollection < T > in (
	                                            Collection < T > collection )
	{
		if ( AliasFactory
		                 .about ( collection ) == null )
		{
			throw new IllegalStateException ( ) ;
		}
		return new InCollection < T > (
		                                collection ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:15:51</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param <V>
	 * @param stateField
	 * @param subquery
	 * @return
	 *//*
	public static < W , V extends W > ConditionalExpression in (
	                                                             final V stateField ,
	                                                             final ISubQuery < W > subquery )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				StringBuilder stringBuilder =
				                              new StringBuilder (
				                                                  AliasFactory
				                                                              .safeStringForm ( stateField ) ) ;
				stringBuilder
				             .append (
				                       " IN (" )
				             .append (
				                       subquery
				                               .toString ( ) )
				             .append (
				                       ')' ) ;
				return stringBuilder
				                    .toString ( ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:16:42</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param <V>
	 * @param stateField
	 * @param inItem
	 * @param more
	 * @return
	 *//*
	public static < W , V extends W > ConditionalExpression in (
	                                                             final V stateField ,
	                                                             final W inItem ,
	                                                             final W ... more )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				StringBuilder stringBuilder =
				                              new StringBuilder (
				                                                  AliasFactory
				                                                              .safeStringForm ( stateField ) ) ;
				stringBuilder
				             .append (
				                       " IN (" )
				             .append (
				                       AliasFactory
				                                   .safeStringForm ( inItem ) ) ;
				if ( more != null )
				{
					for ( W addtional : more )
					{
						stringBuilder
						             .append (
						                       ", " )
						             .append (
						                       AliasFactory
						                                   .safeStringForm ( addtional ) ) ;
					}
				}
				stringBuilder
				             .append ( ')' ) ;
				return stringBuilder
				                    .toString ( ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:02:23</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param multiValued
	 * @return
	 *//*
	public static ConditionalExpression isEmpty (
	                                              final Collection < ? > multiValued )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( multiValued )
				       + " IS EMPTY" ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:16:59</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param multiValued
	 * @return
	 *//*
	public static ConditionalExpression isNotEmpty (
	                                                 final Collection < ? > multiValued )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( multiValued )
				       + " IS NOT EMPTY " ;
			}
		} ;
	}

	public static void isNotNull (
	                               final Collection < ? > singleValued )
	{
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:17:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param singleValued
	 * @return
	 *//*
	public static ConditionalExpression isNotNull (
	                                                final Object singleValued )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( singleValued )
				       + " IS NOT NULL" ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:17:26</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param multiValued
	 *//*
	public static void isNull (
	                            final Collection < ? > multiValued )
	{
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:17:51</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param singleValued
	 * @return
	 *//*
	public static ConditionalExpression isNull (
	                                             final Object singleValued )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( singleValued )
				       + " IS NULL" ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:30:04</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression like (
	                                           ISubQuery < String > lhs ,
	                                           String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                LikeOperator.LIKE ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:58</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @param escape
	 * @return
	 *//*
	public static ConditionalExpression like (
	                                           ISubQuery < String > lhs ,
	                                           String rhs ,
	                                           Character escape )
	{
		return new TernaryExpression < ISubQuery < String > , String , Character > (
		                                                                             lhs ,
		                                                                             LikeOperator.LIKE ,
		                                                                             rhs ,
		                                                                             escape ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:30:15</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression like (
	                                           String lhs ,
	                                           String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  LikeOperator.LIKE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:30:09</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @param escape
	 * @return
	 *//*
	public static ConditionalExpression like (
	                                           String lhs ,
	                                           String rhs ,
	                                           Character escape )
	{
		return new TernaryExpression < String , String , Character > (
		                                                               lhs ,
		                                                               LikeOperator.LIKE ,
		                                                               rhs ,
		                                                               escape ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Character lhs ,
	                                         AllOrAny < Character > rhs )
	{
		return new BinaryExpression < Character , AllOrAny < Character >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.LT ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:43</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Character lhs ,
	                                         Character rhs )
	{
		return new BinaryExpression < Character , Character > (
		                                                        lhs ,
		                                                        ComparisonOperator.LT ,
		                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Character lhs ,
	                                         ISubQuery < Character > rhs )
	{
		return new BinaryExpression < Character , ISubQuery < Character >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.LT ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:29</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Date lhs ,
	                                         AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.LT ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:56</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Date lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              ComparisonOperator.LT ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Date lhs ,
	                                         ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.LT ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:43</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         ISubQuery < ? extends Date > lhs ,
	                                         Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.LT ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:36</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         ISubQuery < ? extends Number > lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          ComparisonOperator.LT ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:32</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         ISubQuery < Character > lhs ,
	                                         Character rhs )
	{
		return new BinaryExpression < ISubQuery < Character > , Character > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.LT ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:21</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         ISubQuery < String > lhs ,
	                                         String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                ComparisonOperator.LT ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:18:11</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression lt (
	                                                             ISubQuery < V > lhs ,
	                                                             AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  ComparisonOperator.LT ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:59</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression lt (
	                                                             ISubQuery < V > lhs ,
	                                                             ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   ComparisonOperator.LT ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:20</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Number lhs ,
	                                         AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        ComparisonOperator.LT ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:09</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Number lhs ,
	                                         ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         ComparisonOperator.LT ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:14</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         Number lhs ,
	                                         Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  ComparisonOperator.LT ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:29:02</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         String lhs ,
	                                         AllOrAny < String > rhs )
	{
		return new BinaryExpression < String , AllOrAny < String >> (
		                                                              lhs ,
		                                                              ComparisonOperator.LT ,
		                                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:51</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         String lhs ,
	                                         ISubQuery < String > rhs )
	{
		return new BinaryExpression < String , ISubQuery < String >> (
		                                                               lhs ,
		                                                               ComparisonOperator.LT ,
		                                                               rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:28:57</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lt (
	                                         String lhs ,
	                                         String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  ComparisonOperator.LT ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:54</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Character lhs ,
	                                          AllOrAny < Character > rhs )
	{
		return new BinaryExpression < Character , AllOrAny < Character >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.LTE ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Character lhs ,
	                                          Character rhs )
	{
		return new BinaryExpression < Character , Character > (
		                                                        lhs ,
		                                                        ComparisonOperator.LTE ,
		                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:46</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Character lhs ,
	                                          ISubQuery < Character > rhs )
	{
		return new BinaryExpression < Character , ISubQuery < Character >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.LTE ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Date lhs ,
	                                          AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    ComparisonOperator.LTE ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:52</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Date lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              ComparisonOperator.LTE ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:35</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Date lhs ,
	                                          ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     ComparisonOperator.LTE ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:51</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          ISubQuery < ? extends Date > lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.LTE ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:47</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          ISubQuery < ? extends Number > lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          ComparisonOperator.LTE ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:35</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          ISubQuery < Character > lhs ,
	                                          Character rhs )
	{
		return new BinaryExpression < ISubQuery < Character > , Character > (
		                                                                      lhs ,
		                                                                      ComparisonOperator.LTE ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:31</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          ISubQuery < String > lhs ,
	                                          String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                ComparisonOperator.LTE ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:18:06</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression lte (
	                                                              ISubQuery < V > lhs ,
	                                                              AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  ComparisonOperator.LTE ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:13</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression lte (
	                                                              ISubQuery < V > lhs ,
	                                                              ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   ComparisonOperator.LTE ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:29</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Number lhs ,
	                                          AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        ComparisonOperator.LTE ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:19</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Number lhs ,
	                                          ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         ComparisonOperator.LTE ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:24</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          Number lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  ComparisonOperator.LTE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:11</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          String lhs ,
	                                          AllOrAny < String > rhs )
	{
		return new BinaryExpression < String , AllOrAny < String >> (
		                                                              lhs ,
		                                                              ComparisonOperator.LTE ,
		                                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:26:58</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          String lhs ,
	                                          ISubQuery < String > rhs )
	{
		return new BinaryExpression < String , ISubQuery < String >> (
		                                                               lhs ,
		                                                               ComparisonOperator.LTE ,
		                                                               rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:27:03</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression lte (
	                                          String lhs ,
	                                          String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  ComparisonOperator.LTE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:15:10</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param element
	 * @param collection
	 * @return
	 *//*
	public static < W > ConditionalExpression memberOf (
	                                                     final W element ,
	                                                     final Collection < ? super W > collection )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( element )
				       + " MEMBER OF "
				       + AliasFactory
				                     .safeStringForm ( collection ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:12:13</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Date lhs ,
	                                          AllOrAny < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , AllOrAny < ? extends Date >> (
		                                                                    lhs ,
		                                                                    EqualityOperator.NOT_EQUALS ,
		                                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:11:08</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Date lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < Date , Date > (
		                                              lhs ,
		                                              EqualityOperator.NOT_EQUALS ,
		                                              rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:11:03</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Date lhs ,
	                                          ISubQuery < ? extends Date > rhs )
	{
		return new BinaryExpression < Date , ISubQuery < ? extends Date >> (
		                                                                     lhs ,
		                                                                     EqualityOperator.NOT_EQUALS ,
		                                                                     rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:10:51</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          ISubQuery < ? extends Date > lhs ,
	                                          Date rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Date > , Date > (
		                                                                      lhs ,
		                                                                      EqualityOperator.NOT_EQUALS ,
		                                                                      rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:10:18</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          ISubQuery < ? extends Number > lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < ISubQuery < ? extends Number > , Number > (
		                                                                          lhs ,
		                                                                          EqualityOperator.NOT_EQUALS ,
		                                                                          rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:18:18</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression neq (
	                                                              ISubQuery < V > lhs ,
	                                                              AllOrAny < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , AllOrAny < W >> (
		                                                                  lhs ,
		                                                                  EqualityOperator.NOT_EQUALS ,
		                                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:25:32</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression neq (
	                                                              ISubQuery < V > lhs ,
	                                                              ISubQuery < W > rhs )
	{
		return new BinaryExpression < ISubQuery < V > , ISubQuery < W >> (
		                                                                   lhs ,
		                                                                   EqualityOperator.NOT_EQUALS ,
		                                                                   rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:11:55</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Number lhs ,
	                                          AllOrAny < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , AllOrAny < ? extends Number >> (
		                                                                        lhs ,
		                                                                        EqualityOperator.NOT_EQUALS ,
		                                                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:08:37</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Number lhs ,
	                                          ISubQuery < ? extends Number > rhs )
	{
		return new BinaryExpression < Number , ISubQuery < ? extends Number >> (
		                                                                         lhs ,
		                                                                         EqualityOperator.NOT_EQUALS ,
		                                                                         rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:08:43</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression neq (
	                                          Number lhs ,
	                                          Number rhs )
	{
		return new BinaryExpression < Number , Number > (
		                                                  lhs ,
		                                                  EqualityOperator.NOT_EQUALS ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:07:53</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression neq (
	                                                              V lhs ,
	                                                              AllOrAny < W > rhs )
	{
		return new BinaryExpression < V , AllOrAny < W >> (
		                                                    lhs ,
		                                                    EqualityOperator.NOT_EQUALS ,
		                                                    rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:07:18</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param <W>
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static < V , W extends V > ConditionalExpression neq (
	                                                              V lhs ,
	                                                              W rhs )
	{
		return new BinaryExpression < V , W > (
		                                        lhs ,
		                                        EqualityOperator.NOT_EQUALS ,
		                                        rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:00</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param negated
	 * @return
	 *//*
	public static ConditionalExpression not (
	                                          final ConditionalExpression negated )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return "NOT "
				       + negated
				                .getTargetRepresentation ( ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:25:14</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Character lhs ,
	                                                 Character rhs1 ,
	                                                 Character rhs2 )
	{
		return new TernaryExpression < Character , Character , Character > (
		                                                                     lhs ,
		                                                                     BetweenOperator.NOT_BETWEEN ,
		                                                                     rhs1 ,
		                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:25:09</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Character lhs ,
	                                                 Character rhs1 ,
	                                                 ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < Character , Character , ISubQuery < Character >> (
		                                                                                  lhs ,
		                                                                                  BetweenOperator.NOT_BETWEEN ,
		                                                                                  rhs1 ,
		                                                                                  rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:25:01</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Character lhs ,
	                                                 ISubQuery < Character > rhs1 ,
	                                                 Character rhs2 )
	{
		return new TernaryExpression < Character , ISubQuery < Character > , Character > (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.NOT_BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:24:53</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Character lhs ,
	                                                 ISubQuery < Character > rhs1 ,
	                                                 ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < Character , ISubQuery < Character > , ISubQuery < Character >> (
		                                                                                                lhs ,
		                                                                                                BetweenOperator.NOT_BETWEEN ,
		                                                                                                rhs1 ,
		                                                                                                rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:24:43</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Date lhs ,
	                                                 Date rhs1 ,
	                                                 Date rhs2 )
	{
		return new TernaryExpression < Date , Date , Date > (
		                                                      lhs ,
		                                                      BetweenOperator.NOT_BETWEEN ,
		                                                      rhs1 ,
		                                                      rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:24:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Date lhs ,
	                                                 Date rhs1 ,
	                                                 ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < Date , Date , ISubQuery < ? extends Date >> (
		                                                                             lhs ,
		                                                                             BetweenOperator.NOT_BETWEEN ,
		                                                                             rhs1 ,
		                                                                             rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:24:30</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Date lhs ,
	                                                 ISubQuery < ? extends Date > rhs1 ,
	                                                 Date rhs2 )
	{
		return new TernaryExpression < Date , ISubQuery < ? extends Date > , Date > (
		                                                                              lhs ,
		                                                                              BetweenOperator.NOT_BETWEEN ,
		                                                                              rhs1 ,
		                                                                              rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:24:24</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Date lhs ,
	                                                 ISubQuery < ? extends Date > rhs1 ,
	                                                 ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < Date , ISubQuery < ? extends Date > , ISubQuery < ? extends Date >> (
		                                                                                                     lhs ,
		                                                                                                     BetweenOperator.NOT_BETWEEN ,
		                                                                                                     rhs1 ,
		                                                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:34</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Date > lhs ,
	                                                 Date rhs1 ,
	                                                 Date rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , Date , Date > (
		                                                                              lhs ,
		                                                                              BetweenOperator.NOT_BETWEEN ,
		                                                                              rhs1 ,
		                                                                              rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:27</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Date > lhs ,
	                                                 Date rhs1 ,
	                                                 ISubQuery < ? extends Date > rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , Date , ISubQuery < ? extends Date >> (
		                                                                                                     lhs ,
		                                                                                                     BetweenOperator.NOT_BETWEEN ,
		                                                                                                     rhs1 ,
		                                                                                                     rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:15</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Date > lhs ,
	                                                 ISubQuery < ? extends Date > rhs1 ,
	                                                 Date rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Date > , ISubQuery < ? extends Date > , Date > (
		                                                                                                      lhs ,
		                                                                                                      BetweenOperator.NOT_BETWEEN ,
		                                                                                                      rhs1 ,
		                                                                                                      rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:21:36</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Number > lhs ,
	                                                 ISubQuery < ? extends Number > rhs1 ,
	                                                 Number rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , ISubQuery < ? extends Number > , Number > (
		                                                                                                            lhs ,
		                                                                                                            BetweenOperator.NOT_BETWEEN ,
		                                                                                                            rhs1 ,
		                                                                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:21:40</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Number > lhs ,
	                                                 Number rhs1 ,
	                                                 ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , Number , ISubQuery < ? extends Number >> (
		                                                                                                           lhs ,
		                                                                                                           BetweenOperator.NOT_BETWEEN ,
		                                                                                                           rhs1 ,
		                                                                                                           rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:02</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < ? extends Number > lhs ,
	                                                 Number rhs1 ,
	                                                 Number rhs2 )
	{
		return new TernaryExpression < ISubQuery < ? extends Number > , Number , Number > (
		                                                                                    lhs ,
		                                                                                    BetweenOperator.NOT_BETWEEN ,
		                                                                                    rhs1 ,
		                                                                                    rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:21:14</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < Character > lhs ,
	                                                 Character rhs1 ,
	                                                 Character rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , Character , Character > (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.NOT_BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:21:04</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < Character > lhs ,
	                                                 Character rhs1 ,
	                                                 ISubQuery < Character > rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , Character , ISubQuery < Character >> (
		                                                                                                lhs ,
		                                                                                                BetweenOperator.NOT_BETWEEN ,
		                                                                                                rhs1 ,
		                                                                                                rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:20:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < Character > lhs ,
	                                                 ISubQuery < Character > rhs1 ,
	                                                 Character rhs2 )
	{
		return new TernaryExpression < ISubQuery < Character > , ISubQuery < Character > , Character > (
		                                                                                                 lhs ,
		                                                                                                 BetweenOperator.NOT_BETWEEN ,
		                                                                                                 rhs1 ,
		                                                                                                 rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:20:11</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < String > lhs ,
	                                                 ISubQuery < String > rhs1 ,
	                                                 String rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , ISubQuery < String > , String > (
		                                                                                        lhs ,
		                                                                                        BetweenOperator.NOT_BETWEEN ,
		                                                                                        rhs1 ,
		                                                                                        rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:20:26</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < String > lhs ,
	                                                 String rhs1 ,
	                                                 ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , String , ISubQuery < String >> (
		                                                                                       lhs ,
		                                                                                       BetweenOperator.NOT_BETWEEN ,
		                                                                                       rhs1 ,
		                                                                                       rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:20:36</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 ISubQuery < String > lhs ,
	                                                 String rhs1 ,
	                                                 String rhs2 )
	{
		return new TernaryExpression < ISubQuery < String > , String , String > (
		                                                                          lhs ,
		                                                                          BetweenOperator.NOT_BETWEEN ,
		                                                                          rhs1 ,
		                                                                          rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:24</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Number lhs ,
	                                                 ISubQuery < ? extends Number > rhs1 ,
	                                                 ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < Number , ISubQuery < ? extends Number > , ISubQuery < ? extends Number >> (
		                                                                                                           lhs ,
		                                                                                                           BetweenOperator.NOT_BETWEEN ,
		                                                                                                           rhs1 ,
		                                                                                                           rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:34</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Number lhs ,
	                                                 ISubQuery < ? extends Number > rhs1 ,
	                                                 Number rhs2 )
	{
		return new TernaryExpression < Number , ISubQuery < ? extends Number > , Number > (
		                                                                                    lhs ,
		                                                                                    BetweenOperator.NOT_BETWEEN ,
		                                                                                    rhs1 ,
		                                                                                    rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:44</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Number lhs ,
	                                                 Number rhs1 ,
	                                                 ISubQuery < ? extends Number > rhs2 )
	{
		return new TernaryExpression < Number , Number , ISubQuery < ? extends Number >> (
		                                                                                   lhs ,
		                                                                                   BetweenOperator.NOT_BETWEEN ,
		                                                                                   rhs1 ,
		                                                                                   rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:49</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 Number lhs ,
	                                                 Number rhs1 ,
	                                                 Number rhs2 )
	{
		return new TernaryExpression < Number , Number , Number > (
		                                                            lhs ,
		                                                            BetweenOperator.NOT_BETWEEN ,
		                                                            rhs1 ,
		                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:45</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 String lhs ,
	                                                 ISubQuery < String > rhs1 ,
	                                                 ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < String , ISubQuery < String > , ISubQuery < String >> (
		                                                                                       lhs ,
		                                                                                       BetweenOperator.NOT_BETWEEN ,
		                                                                                       rhs1 ,
		                                                                                       rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:22:57</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 String lhs ,
	                                                 ISubQuery < String > rhs1 ,
	                                                 String rhs2 )
	{
		return new TernaryExpression < String , ISubQuery < String > , String > (
		                                                                          lhs ,
		                                                                          BetweenOperator.NOT_BETWEEN ,
		                                                                          rhs1 ,
		                                                                          rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:04</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 String lhs ,
	                                                 String rhs1 ,
	                                                 ISubQuery < String > rhs2 )
	{
		return new TernaryExpression < String , String , ISubQuery < String >> (
		                                                                         lhs ,
		                                                                         BetweenOperator.NOT_BETWEEN ,
		                                                                         rhs1 ,
		                                                                         rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:23:14</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs1
	 * @param rhs2
	 * @return
	 *//*
	public static ConditionalExpression notBetween (
	                                                 String lhs ,
	                                                 String rhs1 ,
	                                                 String rhs2 )
	{
		return new TernaryExpression < String , String , String > (
		                                                            lhs ,
		                                                            BetweenOperator.NOT_BETWEEN ,
		                                                            rhs1 ,
		                                                            rhs2 ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:38</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param subquery
	 * @return
	 *//*
	public static ConditionalExpression notExists (
	                                                final ISubQuery < ? > subquery )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return "NOT EXISTS ("
				       + subquery
				                 .toString ( )
				       + ")" ;
			}

		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:15:30</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param <V>
	 * @param stateField
	 * @param subquery
	 * @return
	 *//*
	public static < W , V extends W > ConditionalExpression notIn (
	                                                                final V stateField ,
	                                                                final ISubQuery < W > subquery )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				StringBuilder stringBuilder =
				                              new StringBuilder (
				                                                  AliasFactory
				                                                              .safeStringForm ( stateField ) ) ;
				stringBuilder
				             .append (
				                       " NOT IN (" )
				             .append (
				                       subquery
				                               .toString ( ) )
				             .append (
				                       ')' ) ;
				return stringBuilder
				                    .toString ( ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:16:19</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param <V>
	 * @param stateField
	 * @param inItem
	 * @param more
	 * @return
	 *//*
	public static < W , V extends W > ConditionalExpression notIn (
	                                                                final V stateField ,
	                                                                final W inItem ,
	                                                                final W ... more )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				StringBuilder stringBuilder =
				                              new StringBuilder (
				                                                  AliasFactory
				                                                              .safeStringForm ( stateField ) ) ;
				stringBuilder
				             .append (
				                       " NOT IN (" )
				             .append (
				                       AliasFactory
				                                   .safeStringForm ( inItem ) ) ;
				if ( more != null )
				{
					for ( W addtional : more )
					{
						stringBuilder
						             .append (
						                       ", " )
						             .append (
						                       AliasFactory
						                                   .safeStringForm ( addtional ) ) ;
					}
				}
				stringBuilder
				             .append ( ')' ) ;
				return stringBuilder
				                    .toString ( ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:19:25</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression notLike (
	                                              ISubQuery < String > lhs ,
	                                              String rhs )
	{
		return new BinaryExpression < ISubQuery < String > , String > (
		                                                                lhs ,
		                                                                LikeOperator.NOT_LIKE ,
		                                                                rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:19:07</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @param escape
	 * @return
	 *//*
	public static ConditionalExpression notLike (
	                                              ISubQuery < String > lhs ,
	                                              String rhs ,
	                                              Character escape )
	{
		return new TernaryExpression < ISubQuery < String > , String , Character > (
		                                                                             lhs ,
		                                                                             LikeOperator.NOT_LIKE ,
		                                                                             rhs ,
		                                                                             escape ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:19:39</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @return
	 *//*
	public static ConditionalExpression notLike (
	                                              String lhs ,
	                                              String rhs )
	{
		return new BinaryExpression < String , String > (
		                                                  lhs ,
		                                                  LikeOperator.NOT_LIKE ,
		                                                  rhs ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:19:34</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param lhs
	 * @param rhs
	 * @param escape
	 * @return
	 *//*
	public static ConditionalExpression notLike (
	                                              String lhs ,
	                                              String rhs ,
	                                              Character escape )
	{
		return new TernaryExpression < String , String , Character > (
		                                                               lhs ,
		                                                               LikeOperator.NOT_LIKE ,
		                                                               rhs ,
		                                                               escape ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:59</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param element
	 * @param collection
	 * @return
	 *//*
	public static < W > ConditionalExpression notMemberOf (
	                                                        final W element ,
	                                                        final Collection < ? super W > collection )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return AliasFactory
				                   .safeStringForm ( element )
				       + " NOT MEMBER OF "
				       + AliasFactory
				                     .safeStringForm ( collection ) ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:06:18</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <V>
	 * @param identificationVariable
	 * @return
	 *//*
	public static < V > V object (
	                               final V identificationVariable )
	{
		V v =
		      LibraPersistentObjectFactory.INSTANCE
		                                           .makeNew ( identificationVariable ) ;
		AliasFactory
		            .remember (
		                        v ,
		                        new LibraManagedObject ( )
		                        {
			                        @ Override
			                        public String getTargetRepresentation ( )
			                        {
				                        return "OBJECT("
				                               + AliasFactory
				                                             .safeStringForm ( identificationVariable )
				                               + ")" ;
			                        }
		                        } ) ;
		return v ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:12</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param what
	 * @return
	 *//*
	public static ConditionalExpression paren (
	                                            final ConditionalExpression what )
	{
		return new ConditionalExpression ( )
		{
			@ Override
			public String getTargetRepresentation ( )
			{
				return "("
				       + what
				             .getTargetRepresentation ( )
				       + ")" ;
			}
		} ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:04:53</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param prop
	 * @param more
	 * @return
	 *//*
	public static SelectClause < Object [ ] > select (
	                                                   Object prop ,
	                                                   Object ... more )
	{
		return new SelectClause < Object [ ] > (
		                                         ObjectUtil
		                                                   .merge (
		                                                            Object.class ,
		                                                            prop ,
		                                                            more ) ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:05:36</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <S>
	 * @param prop
	 * @return
	 *//*
	public static < S > SelectClause < S > select (
	                                                S prop )
	{
		return new SelectClause < S > (
		                                new Object [ ]
		                                {
			                                prop
		                                } ) ;
	}

	*//**
	 * <ul>
	 * <li>设计作者：刘川</li>
	 * <li>设计日期：2009-8-10</li>
	 * <li>设计时间：下午05:14:17</li>
	 * <li>设计目的：</li>
	 * </ul>
	 * <ul>
	 * <b>修订历史</b>
	 * <li>1、</li>
	 * </ul>
	 * 
	 * @param <W>
	 * @param subquery
	 * @return
	 *//*
	public static < W > AllOrAny < W > some (
	                                          final ISubQuery < W > subquery )
	{
		return new AllOrAny < W > (
		                            AllOrAnyOperator.SOME ,
		                            subquery ) ;
	}

	*//**
	 * 构造函数
	 *//*
	private DomainQuery ( )
	{
		super ( ) ;
	}
}*/
